Replace the _simple_case_mappings map with a block table - #25

simple_case_mapping() searched a sorted array of 2989 entries with
std::lower_bound, which is about 12 dependent loads per lookup. It is
called once per character, so it dominates to_uppercase() and friends.

Emit the table the way every other property table is already emitted
instead: a uint16_t index per code point (block size 256, 27 of 490
blocks materialised) plus a flat char32_t[3] value array. Row 0 is a
"no mapping" sentinel, so the index doubles as the found/not-found
flag and no separate presence check is needed. The index table stops
after the last mapped code point (U+1E943) rather than covering the
whole code point space.

generateTable() gains two things to support this, both defaulting to
the previous behaviour so every other generated table comes out byte
for byte identical:

- an optional blockSize override. findBestBlockSize() hardcodes an
  8-byte item size, so it picks 64 for this uint16_t index table where
  256 is about 10 kB smaller.
- tables that do not span the whole code point space are padded to a
  whole number of blocks, and get_value() gets a bounds check against
  the table length instead of 0x10FFFF.

to_uppercase() over a 500k character string, 20 iterations, Apple
M-series, clang -O2, median of 3 runs:

                    sorted array   block table
    ASCII              318.7 ms      153.9 ms
    mixed scripts      305.1 ms      134.8 ms

simple_case_mapping() returns identical results for all 1114112 code
points and all three mapping types.

full_case_mapping() searches _special_case_mappings and
_special_case_mappings_default with std::lower_bound for every
character, same as the simple case mapping table did before the
previous commit. case_folding()/simple_case_folding() do the same
against _case_foldings. Convert all three to block tables for the
same reason: they are looked up once per character, so std::lower_bound
dominates to_uppercase()/to_case_fold() even though the tables
themselves are small.

_special_case_mappings has several code points with more than one
entry (full_case_mapping() walks them in SpecialCasing.txt order and
applies the first whose language/context condition matches), so it
is grouped as {offset, count} into a flat SpecialCasing array, the
same shape as the existing script extension tables, keyed by code
point through a block table. _special_case_mappings_default and
_case_foldings have one entry per code point, so they follow the
simple case mapping table's shape directly: a block table index plus
a flat value array with row 0 as a "no entry" sentinel.

_find_code_point() and the SpecialCaseMapping/CaseFoldingEntry
wrapper structs it operated on are no longer used by anything and are
removed.

to_uppercase() over a 500k character string, 20 iterations, Apple
M-series, clang -O2, median of 3 runs:

                    master (sorted array)   this commit
    ASCII                 319.5 ms             52.6 ms
    mixed scripts         306.2 ms             51.7 ms

Isolating just the two special-casing searches previously accounted
for 118 of the 155 ms this branch spent per to_uppercase() call
before this commit; that's gone now.

simple_case_mapping(), simple_case_folding(), full_case_mapping()
(all four locales/contexts x code points), and normalization all
return identical results to master before the sorted-array commit,
checked exhaustively over all 1114112 code points. Full test suite
passes (770963 assertions in 59 test cases), clean with
-Wall -Wextra -Werror on clang.